# -*- coding: utf-8 -*-

import ctypes
import os
import time
import random
import pythoncom
from datetime import datetime
from comtypes.client import CreateObject

error_res = {
    -1: "表示你使用了绑定里的收费功能，但是没注册，无法使用. ",
    -2: "使用模式0 2 时出现，因为目标窗口有保护. 常见于win7以上系统.或者有安全软件拦截插件.解决办法: 关闭所有安全软件，"
          "然后再重新尝试. 如果还不行就可以肯定是目标窗口有特殊保护.",
    -3: "使用模式0 2 时出现，可能目标窗口有保护，也可能是异常错误. 可以尝试换绑定模式或许可以解决.",
    -4: "使用模式101 103时出现，这是异常错误. ",
    -5: "使用模式101 103时出现, 这个错误的解决办法就是关闭目标窗口，重新打开再绑定即可. 也可能是运行脚本的进程没有管理员权限.  ",
    -6: "被安全软件拦截。典型的是金山.360等. 如果是360关闭即可。 如果是金山，必须卸载，关闭是没用的.",
    -7: "使用模式101 103时出现,异常错误. 还有可能是安全软件的问题，比如360等。尝试卸载360. ",
    -9: "使用模式101 103时出现,异常错误. 还有可能是安全软件的问题，比如360等。尝试卸载360. ",
    -8: "使用模式101 103时出现, 目标进程可能有保护,也可能是插件版本过老，试试新的或许可以解决. "
          "-8可以尝试使用DmGuard中的np2盾配合.",
    -10: "使用模式101 103时出现, 目标进程可能有保护,也可能是插件版本过老，试试新的或许可以解决. "
           "-8可以尝试使用DmGuard中的np2盾配合.",
    -11: "使用模式101 103时出现, 目标进程有保护. 告诉我解决。",
    -12: "使用模式101 103时出现, 目标进程有保护. 告诉我解决。",
    -13: "使用模式101 103时出现, 目标进程有保护. 或者是因为上次的绑定没有解绑导致。 尝试在绑定前调用ForceUnBindWindow.",
    -37: "使用模式101 103时出现, 目标进程有保护. 告诉我解决。",
    -14: "可能系统缺少部分DLL,尝试安装d3d. 或者是鼠标或者键盘使用了dx.mouse.api或者dx.keypad.api，"
           "但实际系统没有插鼠标和键盘. 也有可能是图色中有dx.graphic.3d之类的,但相应的图色被占用,比如全屏D3D程序.",
    -16: "可能使用了绑定模式 0 和 101，然后可能指定了一个子窗口.导致不支持.可以换模式2或者103来尝试. "
           "另外也可以考虑使用父窗口或者顶级窗口.来避免这个错误。还有可能是目标窗口没有正常解绑 然后再次绑定的时候. ",
    -17: "模式101 103时出现. 这个是异常错误. 告诉我解决. ",
    -18: "句柄无效.",
    -19: "使用模式0 11 101时出现,这是异常错误,告诉我解决. ",
    -20: "使用模式101 103 时出现,说明目标进程里没有解绑，并且子绑定达到了最大. 尝试在返回这个错误时，"
           "调用ForceUnBindWindow来强制解除绑定.  ",
    -21: "使用模式任何模式时出现,说明目标进程已经存在了绑定(没有正确解绑就退出了?被其它软件绑定?,或者多个线程"
           "同时进行了绑定?). 尝试在返回这个错误时，调用ForceUnBindWindow来强制解除绑定.或者检查自己的代码. ",
    -22: "使用模式0 2,绑定64位进程窗口时出现,因为安全软件拦截插件释放的EXE文件导致. ",
    -23: "使用模式0 2,绑定64位进程窗口时出现,因为安全软件拦截插件释放的DLL文件导致. ",
    -24: "使用模式0 2,绑定64位进程窗口时出现,因为安全软件拦截插件运行释放的EXE.",
    -25: "使用模式0 2,绑定64位进程窗口时出现,因为安全软件拦截插件运行释放的EXE.",
    -26: "使用模式0 2,绑定64位进程窗口时出现, 因为目标窗口有保护. 常见于win7以上系统.或者有安全软件拦截插件."
         "解决办法: 关闭所有安全软件，然后再重新尝试. 如果还不行就可以肯定是目标窗口有特殊保护.",
    -27: "绑定64位进程窗口时出现，因为使用了不支持的模式，目前暂时只支持模式0 2 11 13 101 103 ",
    -28: "绑定32位进程窗口时出现，因为使用了不支持的模式，目前暂时只支持模式0 2 11 13 101 103 ",
    -38: "是用了大于2的绑定模式,并且使用了dx.public.inject.c时，分配内存失败. 可以考虑开启memory系列盾来尝试.",
    -39: "是用了大于2的绑定模式,并且使用了dx.public.inject.c时的异常错误. 可以联系我解决.  ",
    -40: "是用了大于2的绑定模式,并且使用了dx.public.inject.c时, 写入内存失败. 可以考虑开启memory系列盾来尝试.",
    -41: "是用了大于2的绑定模式,并且使用了dx.public.inject.c时的异常错误. 可以联系我解决.  ",
    -42: "绑定时,创建映射内存失败. 这是个异常错误. 一般不会出现. 如果出现了，检查下代码是不是有同个对象同时绑定的情况."
           "还有可能是你的进程有句柄泄露导致无法创建句柄会出这个错误.",
    -43: "绑定时,映射内存失败. 这是个异常错误. 一般不会出现. 如果出现了，一般是你的进程内存不足,"
           "检查下你的进程是不是内存泄漏了.",
    -44: "无效的参数,通常是传递了不支持的参数.",
    -45: "绑定时,创建互斥信号失败. 这个是一场错误. 一般不会出现. 如果出现了检查进程是否有句柄泄漏的情况.  ",
    -100: "调用读写内存函数后，发现无效的窗口句柄",
    -101: "读写内存函数失败 ",
    -200: "AsmCall失败",
    -202: "AsmCall平台兼容问题.联系我解决. "
}
reg_res = {
    -1: " 无法连接网络,(一般原因是用错误注册码或者注册码到期后疯狂注册。注册失败次数过多可能封了一天IP,重启路由器或者明天自动恢复，"
          "也可能防火墙拦截如版本太老连接不上大漠服务器.建议到www.52hsxx.com下载最新dm.dll更换一下dll文件,"
          "具体原因见https://www.eyy8.vip/thread-2452-1-2.html)",
    -2: " 进程没有以管理员方式运行. (出现在win7 win8 vista 2008.建议关闭uac)",
    0: " 失败 (未知错误原因是写的代码不对。注册之前没有创建对象。或者没有注册到系统。如果用的免注册到系统可能代码不对。"
         "鉴别方法很简单。在代码里ver输出一下大漠版本号如果是空。说明没有注册到系统或免注册系统代码不对)",
    1: " 成功",
    2: " 余额不足",
    3: " 绑定了本机器，但是账户余额不足50元.",
    4: " 注册码错误",
    5: " 你的机器或者IP在黑名单列表中或者不在白名单列表中.",
    6: " 非法使用插件.",
    7: "你的帐号因为非法使用被封禁. （如果是在虚拟机中使用插件，必须使用Reg或者RegEx，不能使用RegNoMac或者RegExNoMac,"
         "否则可能会造成封号，或者封禁机器）",
    8: " ver_info不在你设置的附加白名单中，或者余额不足被系统拉黑。如果你是直接买的注册码.可能是余额不足."
         "请下载余额查询工具查询余额下载地址www.52hsxx.com易吧   ",
    77: " 机器码或者IP因为非法使用，而被封禁. （如果是在虚拟机中使用插件，必须使用Reg或者RegEx，不能使用RegNoMac或者RegExNoMac,"
          "否则可能会造成封号，或者封禁机器）封禁是全局的，如果使用了别人的软件导致77，也一样会导致所有注册码均无法注册。"
          "解决办法是更换IP，更换MAC. ",
    -8: " 版本附加信息长度超过了,如果你的版本附加码填写正确.说明你系统里注册使用的大漠版本太老了.请用ver命令输出版本号看看."
          "尽量用7.xx以后的版本.20",
    -9: " 版本附加信息里包含了非法字母,请检查是否有空格什么的..   ",
    "": " 这是不可能返回空的，如果出现空，那肯定是当前使用的版本不对,老的插件里没这个函数导致返回为空.最好参考文档中的标准写法,"
        "判断插件版本号.",
}




def randomUint(start, stop):
    return random.randrange(start, stop, 1)


def randomSleep(min_time, max_time, percent=1.0):
    sleep_time = random.random() * (max_time - min_time) + min_time
    time.sleep(sleep_time * percent)


class DM(object):
    is_block = False

    def __init__(self, log, base_dir=None,public_data=None,ignore_wait=0):
        self.isPause = False
        self.dm = None
        cwd=os.getcwd()
        self.log = log
        location_dm = os.path.join(cwd, r"dm\dm.dll")
        location_dmreg = os.path.join(cwd,r"dm\DmReg.dll")
        # dms = ctypes.cdll.LoadLibrary(location_dmreg)
        self.log.info("开始加载dmReg.dll")
        time.sleep(0.1)
        dms = ctypes.windll.LoadLibrary(location_dmreg)
        self.log.info("开始设置dll path")
        time.sleep(0.1)
        dms.SetDllPathW(location_dm, 0)
        pythoncom.CoInitialize()
        self.log.info("创建大漠对象")
        time.sleep(0.1)
        self.dm = CreateObject("dm.dmsoft")
        time.sleep(0.1)
        self.log.info("加载大漠字典")
        time.sleep(0.1)
        self.dm.SetDict(0, os.path.join(cwd, r"dm\suiyin.txt"))
        self.dm.SetDict(1, os.path.join(cwd, r"dm\lunjian.txt"))
        self.dm.SetDict(2, os.path.join(cwd, r"dm\dm_soft.txt"))
        self.dm.SetDict(3, os.path.join(cwd, r"dm\复活计时.txt"))
        self.error_res = error_res
        if base_dir is None:
            self.baseDir = os.getcwd()
        if public_data is None:
            public_data={"": ""}
        self.publicData = public_data
        self.ignore_wait=ignore_wait
        self.log.info("大漠初始化完成")

    def __getattribute__(self, item):
        if item != "isPause" :
            while True:
                if self.isPause:
                    time.sleep(1)
                    print("暂停中")
                else:
                    break
        return super().__getattribute__(item)
    def Reg(self,dm_user,dm_passwd):
        res = self.dm.Reg(dm_user, dm_passwd)

        if res == 1:
            print("注册成功")
        else:
            msg = reg_res[res]
            print("注册失败，错误码：" + str(res) + msg)

    def UseDict(self,index):
        self.log.info("切换字典%s"% index)
        self.dm.UseDict(index)

    def wait_check(self):
        if not self.ignore_wait:
            self.log.debug("开始巡检等待")
            while DM.is_block :
                time.sleep(0)
            self.log.debug("巡检等待结束")

    @staticmethod
    def SetBlockTrue():
        DM.is_block=True

    @staticmethod
    def SetBlockFalse():
        DM.is_block = False

    @staticmethod
    def GetBlockFalse():
        return DM.is_block

    def Ver(self):
        return self.dm.Ver()

    def IsBind(self, dota2_hwnd):
        return self.dm.IsBind(dota2_hwnd)

    def GetLastError(self):
        error_res = self.dm.GetLastError()
        return error_res, self.error_res[error_res]

    def MoveTo(self, x, y):
        self.wait_check()
        if 21<x< 69 and  45 <y <221:
            self.log.info("mv warning %s,%s " % (x, y))
        self.log.info("mv  %s,%s " % ( x, y))
        return self.dm.MoveTo(x, y)
    def MoveToFast(self, x, y):
        if 21<x< 69 and  45 <y <221:
            self.log.info("mv warning %s,%s " % (x, y))
        self.log.info("mv  %s,%s " % ( x, y))
        return self.dm.MoveTo(x, y)


    def DragFast(self, x1, y1,x2,y2):
        # 这是一个定时函数  不等待
        self.log.info("拖拽 %s %s %s %s" % (x1,y1,x2,y2))
        self.dm.MoveTo(x1,y1)
        time.sleep(0.1)
        self.dm.LeftDown()
        time.sleep(0.1)
        self.dm.MoveTo(x2, y2)
        time.sleep(0.1)
        self.dm.LeftUp()

    def EnablePicCache(self,flag):
        self.dm.EnablePicCache(flag)

    def BindWindowEx(self, hwnd, mode):
        if mode=="前台":
            data = {"display": "normal",
                         "keypad": "normal",
                         "mode": 0,
                         "mouse": "windows",
                         "public": ""}
        else:
            data = {"display": "dx.graphic.3d.10plus",
                         "keypad": "dx.keypad.input.lock.api|dx.keypad.state.api|dx.keypad.api|dx.keypad.raw.input|dx.keypad.raw.input.active",
                         "mode": 0,
                         "mouse": "dx.mouse.input.lock.api2|dx.mouse.position.lock.api|dx.mouse.position.lock.message|dx.mouse.state.message",
                         "public": "dx.public.active.api"}
        self.log.info("%s"%hwnd)
        bind_res = self.dm.BindWindowEx(hwnd, data["display"], data["mouse"], data["keypad"], data["public"], data["mode"])
        if bind_res == 1:
            return 1, ""
        else:
            error_code, err_msg = self.GetLastError()
            return bind_res, err_msg

    def FindWindow(self, class_name, tittle):
        return self.dm.FindWindow(class_name, tittle)
    def FindWindowEx(self,hwnd, class_name, tittle):
        return self.dm.FindWindowEx(hwnd,class_name, tittle)
    def WheelDown(self,n):
        for i in range(n):
            time.sleep(0.052)
            self.dm.WheelDown()
    def WheelUp(self,n):
        for i in range(n):
            time.sleep(0.056)
            self.dm.WheelUp()
    def SetWindowState(self, hwnd, mode):
        return self.dm.SetWindowState(hwnd, mode)

    def UnBindWindow(self,n=3):
        res=0
        for i in range(n):
            self.log.info("解绑")
            res=self.dm.UnBindWindow()
            if res ==1 :
                break
        self.log.info("解绑完成")
        return res


    def MoveWindow(self, hwnd, x, y):
        return self.dm.MoveWindow(hwnd, int(x), int(y))

    def SendString(self, hwnd, text):
        return self.dm.SendString(hwnd, text)

    def SendString2(self, hwnd, text):
        return self.dm.SendString2(hwnd, text)

    def SendStringIme2(self, hwnd, text, mode):
        return self.dm.SendStringIme2(hwnd, text, mode)

    def SendStringIme(self, text):
        return self.dm.SendStringIme( text)


    def KeyPressChars(self, text):
        for i in text:
            self.dm.KeyPressChar(i)
        return

    def KeyPress(self, key_num):
        self.wait_check()
        return self.dm.KeyPress(key_num)

    def KeyPressChar(self, key,no_wait=0,num=1,step=0.3):
        if no_wait!=1:
            self.wait_check()
        for i in range(num):
            self.log.info("按下 %s" % key)
            self.dm.KeyPressChar(key)
            if i< num-1:
                time.sleep(step)

    def EnableBind(self,n):
        return self.dm.EnableBind(n)

    def Capture(self, x1, y1, x2, y2, path):
        path = self.GetPicAbsPath(path)
        return self.dm.Capture(x1, y1, x2, y2, path)

    def SendString(self,hwnd, text):
        return self.dm.SendString(hwnd,text)

    def GetCursorPos(self):
        x, y, res = self.dm.GetCursorPos()
        return x, y, res
    def GetCursorShape(self):
        return self.dm.GetCursorShape()
    def KeyPressStr(self, text, dealy):
        self.wait_check()
        return self.dm.KeyPressStr(text, dealy)
    # 获取窗口位置
    def GetClientRect(self, hwnd):
        return self.dm.GetClientRect(hwnd)

    def FindColor(self, x1, y1, x2, y2,color,sim,direction):
        return self.dm.FindColor(x1, y1, x2, y2,color,sim,direction)

    def DebugScreen(self, tag, x1=0, y1=0, x2=1280, y2=720):
        if self.publicData["系统"]["是否截图"]:
            # 生成当前时间
            now = datetime.now()
            # 以可读格式输出时间
            readable_time = now.strftime("%Y%m%d_%H%M%S")

            path= self.GetPicAbsPath(tag,name="screen") + readable_time + ".bmp"
            res =self.dm.Capture(x1, y1, x2, y2, path)
            return res
        return 1

    # 会返回第几张图片
    def FindPic(self, x1, y1, x2, y2, path, delta_color, sim, direction=0,is_log=True):
        """
        0: 从左到右, 从上到下
        1: 从左到右, 从下到上
        2: 从右到左, 从上到下
        3: 从右到左, 从下到上
        """
        x, y, res = self.dm.FindPic(x1, y1, x2, y2, path, delta_color, sim, direction)
        if is_log:
            self.log.info("查询图片 %s 结果 %s 坐标 %s,%s " % (path, res, x, y))
        return x, y, res

    # 查找图片 有优先级 返回第一张
    def FindPicEx(self, x1, y1, x2, y2, path, delta_color, sim, direction=0,is_log=True):
        res = self.dm.FindPicEx(x1, y1, x2, y2, path, delta_color, sim, direction)
        if is_log:
            self.log.info("查询图片 %s 结果 %s  " % (path, res))
        # id ,x ,y
        if res=="":
            return  -1,-1,-1
        else:
            tmp=res.split("|")[0].split(",")
            tmp[0] = int(tmp[0])
            tmp[1] = int(tmp[1])
            tmp[2] = int(tmp[2])
            return tmp

    # 查找图片 有优先级 返回第一张
    def FindPicExS(self, x1, y1, x2, y2, path, delta_color, sim, direction=0,is_log=True):

        res = self.dm.FindPicExS(x1, y1, x2, y2, path, delta_color, sim, direction)
        if is_log:
            self.log.info("查询图片 %s 结果 %s  " % (path, res))
        # file ,x ,y
        if res == "":
            return -1, -1, -1
        else:
            tmp = res.split("|")[0].split(",")

            tmp[1] = int(tmp[1])
            tmp[2] = int(tmp[2])
            return tmp

    # 查找图片 有优先级 返回所有
    def FindPicExs(self, x1, y1, x2, y2, path, delta_color, sim, direction=0,is_log=True):

        res = self.dm.FindPicEx(x1, y1, x2, y2, path, delta_color, sim, direction)
        if is_log:
            self.log.info("查询图片 %s 结果 %s  " % (path, res))
        if res=="":
            return  []
        else:
            result=[]
            for pic in res.split("|"):
                tmp=[]
                for v in pic.split(",") :
                    tmp.append(int(v))
                result.append(tmp)
        return result

    # 要该 不能返回冲突 todo
    def SearchPngClick(self, x1, y1, x2, y2, path, sim, count, step_time, click_num, rx, ry, is_wait=0,delta_color="000000"):
        """
        找到后 返回1
        找到后 消失 返回 1
        没找到 返回 0
        """

        path = self.GetPicAbsPath(path)
        result = 0
        is_exist = False
        while count > 0:
            count -= 1
            time.sleep(step_time)
            res,x, y  = self.FindPicEx(x1, y1, x2, y2, path, delta_color, sim)
            if x > 0 and y > 0:
                if click_num!=0:
                    self.LeftClick(x + rx, y + ry, click_num)
                result = 1
                is_exist = True
                if is_wait == 0:
                    break
            else:
                if is_exist is True:
                    break
                result = 0
        return result

    # 要该 不能返回冲突 每次点击不同的点 todo
    def SearchPngClickDiff(self, x1, y1, x2, y2, path, sim, count, step_time, click_num, rx, ry, is_wait=0,
                           delta_color="000000"):
            """
            找到后 返回1
            找到后 消失 返回 1
            没找到 返回 0
            """

            path = self.GetPicAbsPath(path)
            result = 0
            is_exist = False
            while count > 0:
                count -= 1
                time.sleep(step_time)
                res = self.FindPicExs(x1, y1, x2, y2, path, delta_color, sim)
                if len(res)!=0:
                    result = 1
                    is_exist = True
                    for tmp in res:
                        if click_num != 0:
                            self.LeftClick(tmp[1] + rx, tmp[2] + ry, click_num)
                            count -= 1
                            if count<0:
                                break
                else:
                    if is_exist is True:
                        break
                    else:
                        result = 0
            return result

    # todo 需要合并
    def SearchPngClickEX(self, x1, y1, x2, y2, path, sim, count, step_time, click_num, rx, ry, is_wait=0,delta_color="000000"):
        """
        找到后 返回1
        找到后 消失 返回 1
        没找到 返回 0
        """

        path = self.GetPicAbsPath(path)
        result = 0
        is_exist = False
        while count > 0:
            count -= 1
            time.sleep(step_time)
            res,x, y  = self.FindPicEx(x1, y1, x2, y2, path, delta_color, sim)
            if x > 0 and y > 0:
                if click_num!=0:
                    self.LeftClick(x + rx, y + ry, click_num)
                result = res
                is_exist = True
                if is_wait == 0:
                    break
            else:
                if is_exist is True:
                    break
                result = -1
        return result

    def SearchPngClickEXS(self, x1, y1, x2, y2, path, sim, count, step_time, click_num, rx, ry, is_wait=0,delta_color="000000"):
        """
        找到后 返回1
        找到后 消失 返回 1
        没找到 返回 0
        """

        path = self.GetPicAbsPath(path)
        result = 0
        is_exist = False
        while count > 0:
            count -= 1
            time.sleep(step_time)
            res,x, y  = self.FindPicExS(x1, y1, x2, y2, path, delta_color, sim)
            if x > 0 and y > 0:
                if click_num!=0:
                    self.LeftClick(x + rx, y + ry, click_num)
                result = res
                is_exist = True
                if is_wait == 0:
                    break
            else:
                if is_exist is True:
                    break
                result = -1
        return result

    def SearchPngClickEXn(self, x1, y1, x2, y2, path, sim, count, step_time, click_num, rx, ry, is_wait=0,delta_color="000000"):
        """
        找到后 返回1
        找到后 消失 返回 1
        没找到 返回 0
        """

        path = self.GetPicAbsPath(path)
        path_list=self.GetPicAbsPath(path).split("|")

        # id, name ,x,y
        result = [-1,"",-1,-1]
        is_exist = False
        while count > 0:
            count -= 1
            time.sleep(step_time)
            pic_id,x, y  = self.FindPicEx(x1, y1, x2, y2, path, delta_color, sim)
            if x > 0 and y > 0:
                if click_num!=0:
                    self.LeftClick(x + rx, y + ry, click_num)
                result = [pic_id,path_list[pic_id],x, y ]
                is_exist = True
                if is_wait == 0:
                    break
            else:
                if is_exist is True:
                    break
                result = [-1,"",-1,-1]
        return result

    # 等待图像消失
    def WaitPngDisappear(self, x1, y1, x2, y2, path, sim, count, step_time, click_num=0, rx=0, ry=0, is_wait=0,delta_color="000000",is_right=0):
        """
        时间内消失 返回0
        超时后存在 返回1
        """
        path = self.GetPicAbsPath(path)
        result = 0
        while count > 0:
            count -= 1
            time.sleep(step_time)
            x, y, res = self.FindPic(x1, y1, x2, y2, path, delta_color, sim)
            if x > 0 and y > 0:
                if click_num!=0:
                    if is_right==0:
                        self.LeftClick(x + rx, y + ry, click_num)
                    elif is_right==1:
                        self.RightClick(x + rx, y + ry, click_num)
                result = 1
            else:
                result=0
                break
        return result

    # 等待图像消失
    def WaitPngDisappearDiff(self, x1, y1, x2, y2, path, sim, count, step_time, click_num=0, rx=0, ry=0, is_wait=0,
                         delta_color="000000"):
        """
        时间内消失 返回0
        超时后存在 返回1
        """
        path = self.GetPicAbsPath(path)
        result = 0
        while count > 0:
            count -= 1
            time.sleep(step_time)
            res = self.FindPicExs(x1, y1, x2, y2, path, delta_color, sim)
            if len(res) == 0:
                break
            for tmp in res:
                result = 1
                if click_num != 0:
                    self.LeftClick(tmp[1] + rx, tmp[2] + ry, click_num)
                    count -= 1
                    if count < 0:
                        break

        return result
    def GetPicAbsPath(self, path,name="pic"):
        res_path_list = []
        path_list = path.split("|")
        for path in path_list:
            if os.path.isabs(path):
                res_path_list.append(path)
            else:
                res_path_list.append(os.path.join(self.baseDir,name ,path))
        return "|".join(res_path_list)

    # 获取路径下所有文件的路径
    def GetDirPath(self, path,filter=""):
        dir_list = []
        for path in path.split("|"):
            if os.path.isabs(path):
                dir_list.append(path)
            else:
                dir_list.append(os.path.join(self.baseDir, path))
        file_list=[]
        for path in dir_list:
            for root,dirs,files in os.walk(path):
                for file_name in files:
                    if filter in  file_name:
                        file_list.append(os.path.join(root,file_name))
        return "|".join(file_list)



    def LeftClick(self, x, y, n=1, x_offset=0, y_offset=0):

        if x_offset != 0:
            x += randomUint(x_offset * -1, x_offset)
        if y_offset != 0:
            y += randomUint(y_offset * -1, y_offset)
        self.MoveTo(x, y)
        randomSleep(0.032, 0.069)

        if n == 1:
            self.wait_check()
            self.log.debug("click " )
            self.dm.LeftClick()
        elif n == 2:
            self.wait_check()
            self.log.debug("click ")
            self.dm.LeftDoubleClick()
        else:
            for number in range(0, n):
                if number != (n-1):
                    randomSleep(0.032, 0.069, 0.3)
                self.wait_check()
                self.log.debug("click x")
                self.dm.LeftClick()

    def RightClick(self, x, y, n, x_offset=0, y_offset=0):

        if x_offset != 0:
            x += randomUint(x_offset * -1, x_offset)
        if y_offset != 0:
            y += randomUint(y_offset * -1, y_offset)
        self.MoveTo(x, y)
        randomSleep(0.132, 0.189)

        if n == 1:
            self.wait_check()
            self.log.debug("click " )
            self.dm.RightClick()
        elif n == 2:
            self.wait_check()
            self.log.debug("click ")
            self.dm.RightClick()
        else:
            for number in range(0, n):
                randomSleep(0.132, 0.189, 0.3)
                self.wait_check()
                self.log.debug("click ")
                self.dm.RightClick()



if __name__ == '__main__':

    x = DM()
    x.reg()
